@miso.ai/doggoganger 0.9.0-beta.5 → 0.9.0-beta.6

package/cli/index.js

@@ -21,6 +21,10 @@ let { watch, ...argv } = yargs(hideBin(process.argv))
     describe: 'Watch files for changes',
     type: 'boolean',
   })
+  .option('answer-format', {
+    describe: 'Answer field format in answers API response',
+    type: 'string',
+  })
   .option('serve', {
     alias: 's',
     describe: 'Serve static files as well',
@@ -28,8 +32,8 @@ let { watch, ...argv } = yargs(hideBin(process.argv))
   })
   .argv;
 
-const { port, serve } = argv;
-argv = { port, serve };
+const { port, serve, ['answer-format']: answerFormat } = argv;
+argv = { port, serve, answerFormat };
 
 if (watch) {
   const exec = `node ${resolve(__dirname, 'server.js')} ${JSON.stringify(JSON.stringify(argv))}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miso.ai/doggoganger",
-  "version": "0.9.0-beta.5",
+  "version": "0.9.0-beta.6",
   "description": "A dummy miso endpoint for demo and testing",
   "type": "module",
   "bin": {

package/src/api/answers.js

@@ -1,20 +1,27 @@
 import Router from '@koa/router';
 import { v4 as uuid } from 'uuid';
-import { lorem, articles, utils } from '../data/index.js';
+import { lorem, md, articles, utils } from '../data/index.js';
 
-const router = new Router();
+const { randomInt } = utils;
 
-const WPS = 20;
+const CPS = 100;
 const ITEMS_LOADING_TIME = 3;
 const STAGES = [
   {
+    name: 'fetch',
     duration: 1.5,
-    text: `Fetching results...`,
+    text: `Checking the question and fetching results...`,
   },
   {
+    name: 'verify',
+    duration: 1.5,
+    text: `Verifying results...`,
+  },
+  {
+    name: 'generate',
     duration: 1.5,
     text: `Generating answer...`,
-  }
+  },
 ];
 
 function formatDatetime(timestamp) {
@@ -22,25 +29,34 @@ function formatDatetime(timestamp) {
   return str.endsWith('Z') ? str.slice(0, -1) : str;
 }
 
+function answer(format) {
+  switch (format) {
+    case 'markdown':
+      return md.markdown({});
+    case 'plaintext':
+    default:
+      return lorem.lorem({
+        min: 50,
+        max: 100,
+        decorates: ['description'],
+      });
+  }
+}
+
 const answers = new Map();
 
 class Answer {
 
-  constructor(question, previous_question_id) {
+  constructor(question, previous_question_id, { answerFormat = 'plaintext' } = {}) {
     this.question_id = uuid();
     this.question = question;
     this.previous_answer_id = previous_question_id;
     this.timestamp = Date.now();
     this.datetime = formatDatetime(this.timestamp);
 
-    this.answer = lorem.lorem({
-      min: 50,
-      max: 100,
-      decorates: ['description'],
-      output: 'array',
-    });
-    this.relatedResources = [...articles({ rows: utils.randomInt(6, 8) })];
-    this.sources = [...articles({ rows: utils.randomInt(4, 6) })];
+    this.answer = answer(answerFormat);
+    this.relatedResources = [...articles({ rows: randomInt(6, 8) })];
+    this.sources = [...articles({ rows: randomInt(4, 6) })];
 
     this.previous_question_id = previous_question_id && answers.get(previous_question_id) || undefined;
     answers.set(this.question_id, this);
@@ -49,13 +65,14 @@ class Answer {
   get() {
     const now = Date.now();
     const elapsed = (now - this.timestamp) / 1000;
-    const [answer, finished] = this._answer(elapsed);
+    const [stage, answer, finished] = this._answer(elapsed);
     const sources = this._sources(elapsed);
     const related_resources = this._relatedResources(elapsed);
     const { question_id, question, datetime, previous_question_id } = this;
 
     return {
       affiliation: undefined,
+      stage,
       answer,
       datetime,
       finished,
@@ -71,13 +88,13 @@ class Answer {
     for (const stage of STAGES) {
       elapsed -= stage.duration;
       if (elapsed < 0) {
-        return [stage.text, false];
+        return [stage.name, stage.text, false];
       }
     }
-    const wordCount = Math.floor(elapsed * WPS);
-    const finished = wordCount >= this.answer.length;
-    const text = (finished ? this.answer : this.answer.slice(0, wordCount)).join(' ');
-    return [text, finished];
+    const length = Math.floor(elapsed * CPS);
+    const finished = length >= this.answer.length;
+    const text = finished ? this.answer : this.answer.slice(0, length);
+    return ['result', text, finished];
   }
 
   _sources(elapsed) {
@@ -96,22 +113,28 @@ class Answer {
 
 }
 
-router.post('/questions', (ctx) => {
-  const { q: question, previous_answer_id } = JSON.parse(ctx.request.body);
-  const answer = new Answer(question, previous_answer_id);
-  const data = answer.get();
-  ctx.body = JSON.stringify({ data });
-});
-
-router.get('/questions/:id/answer', (ctx) => {
-  const { id } = ctx.params;
-  const answer = answers.get(id);
-  if (!answer) {
-    ctx.status = 404;
-  } else {
+export default function({ answerFormat }) {
+  const options = Object.freeze({ answerFormat });
+  const router = new Router();
+
+  router.post('/questions', (ctx) => {
+    const { q: question, previous_answer_id } = JSON.parse(ctx.request.body);
+    const answerFormat = ctx.get('x-answer-format') || options.answerFormat;
+    const answer = new Answer(question, previous_answer_id, { answerFormat });
     const data = answer.get();
     ctx.body = JSON.stringify({ data });
-  }
-});
+  });
+
+  router.get('/questions/:id/answer', (ctx) => {
+    const { id } = ctx.params;
+    const answer = answers.get(id);
+    if (!answer) {
+      ctx.status = 404;
+    } else {
+      const data = answer.get();
+      ctx.body = JSON.stringify({ data });
+    }
+  });
 
-export default router;
+  return router;
+}

package/src/api/index.js

@@ -1,5 +1,5 @@
 import Router from '@koa/router';
-import answers from './answers.js';
+import _answers from './answers.js';
 import recommendation from './recommendation.js';
 import search from './search.js';
 import interactions from './interactions.js';
@@ -8,11 +8,13 @@ function use(router, path, middleware) {
   router.use(path, middleware.routes(), middleware.allowedMethods());
 }
 
-const router = new Router();
+export default function(options) {
+  const router = new Router();
 
-use(router, '/answers', answers);
-use(router, '/recommendation', recommendation);
-use(router, '/search', search);
-use(router, '/interactions', interactions);
+  use(router, '/answers', _answers(options));
+  use(router, '/recommendation', recommendation);
+  use(router, '/search', search);
+  use(router, '/interactions', interactions);
 
-export default router;
+  return router;
+};

package/src/data/articles.js

@@ -1,5 +1,5 @@
 import * as u from './utils.js';
-import * as lorem from './lorem.js';
+import * as fields from './fields.js';
 
 export function *articles({ rows, ...options } = {}) {
   for (let i = 0; i < rows; i++) {
@@ -9,39 +9,16 @@ export function *articles({ rows, ...options } = {}) {
 
 function article({} = {}) {
   const id = u.id();
-  const prices = u.repeat(u.price, 1, 2);
-  prices.sort();
-  const seed = Math.floor(Math.random() * 1000);
 
   return {
     product_id: id,
-    authors: lorem.lorem({
-      min: 1,
-      max: 3,
-      fixedStarts: 0,
-      decorates: ['title'],
-      output: 'array',
-    }),
+    authors: fields.authors(),
     categories: [],
-    tags: lorem.lorem({
-      min: 1,
-      max: 4,
-      fixedStarts: 0,
-      output: 'array',
-    }),
-    title: lorem.lorem({
-      min: 4,
-      max: 10,
-      fixedStarts: 0,
-      decorates: ['title'],
-    }),
-    description: lorem.lorem({
-      min: 20,
-      max: 40,
-      decorates: ['description'],
-    }),
+    tags: fields.tags(),
+    title: fields.title({ size: [4, 10] }),
+    description: fields.description({ size: [20, 40] }),
     //html,
-    cover_image: `https://picsum.photos/seed/${seed}/300`,
+    cover_image: fields.image(),
     url: `/products/${id}`,
   };
 }

package/src/data/fields.js

@@ -0,0 +1,49 @@
+import * as lorem from './lorem.js';
+import { imageUrl } from './utils.js';
+
+export function image({ size = 300 } = {}) {
+  return imageUrl(size);
+}
+
+export function authors({ size = [1, 3] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+    output: 'array',
+  });
+}
+
+export function tags({ size = [1, 4] } = {}) {
+  return lorem.lorem({
+    size,
+    output: 'array',
+  });
+}
+
+// TODO: categories
+
+export function title({ size = [2, 6] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['title'],
+  });
+}
+
+export function description({ size = [10, 20] } = {}) {
+  return lorem.lorem({
+    size,
+    decorates: ['description'],
+  });
+}
+
+export function availability() {
+  return Math.random() > 0.3 ? 'IN_STOCK' : 'OUT_OF_STOCK';
+}
+
+export function price() {
+  return Math.floor(Math.random() * 10000) / 100;
+}
+
+export function rating() {
+  return Math.floor(Math.random() * 500) / 100 + 1;
+}

package/src/data/index.js

@@ -1,3 +1,4 @@
+export * as md from './markdown/index.js';
 export * as lorem from './lorem.js';
 export * from './products.js';
 export * from './articles.js';

package/src/data/lorem.js

@@ -7,8 +7,8 @@ import { randomInt } from './utils.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_WORDS = yaml.load(readFileSync(resolve(__dirname, './words.yaml'), 'utf8'));
 
-export function lorem({ decorates = [], min, max, n, output = 'string', ...options } = {}) {
-  let iterator = limit({ min, max, n })(base(options));
+export function lorem({ decorates = [], output = 'string', size, min, max, ...options } = {}) {
+  let iterator = limit(size || [min, max])(base(options));
   for (const decorate of decorates) {
     iterator = lookup(decorate)(iterator);
   }
@@ -20,14 +20,15 @@ const FNS = {
   array,
   title,
   description,
+  multiline,
 }
 
 function lookup(fn) {
-  return typeof fn === 'string' ? FNS[fn]() : fn();
+  return typeof fn === 'string' ? FNS[fn]() : fn;
 }
 
 // base //
-export function *base({ words = DEFAULT_WORDS, fixedStarts = 2 } = {}) {
+export function *base({ words = DEFAULT_WORDS, fixedStarts = 0 } = {}) {
   const wordsLength = words.length;
   for (let i = 0; ; i++) {
     yield words[i < fixedStarts ? i : Math.floor(Math.random() * wordsLength)];
@@ -43,9 +44,34 @@ export function array() {
   return iterator => [...iterator];
 }
 
+export function multiline({
+  wordsPerLine = {
+    avg: 10,
+    std: 3,
+    min: 1,
+  },
+} = {}) {
+  return iterator => {
+    let slen = gaussMS(wordsPerLine);
+    let result = '';
+    for (let word of iterator) {
+      if (result) {
+        if (slen-- === 0) {
+          result += '\n';
+          slen = gaussMS(wordsPerLine);
+        } else {
+          result += ' ';
+        }
+      }
+      result += word;
+    }
+    return result;
+  }
+}
+
 // decorators //
-export function limit({ n, min = 5, max = 10 }) {
-  n = n || randomInt(min, max);
+export function limit(size = [5, 10]) {
+  const n = typeof size === 'number' ? size : randomInt(...size);
   return function *(iterator) {
     let i = 0;
     for (let word of iterator) {
@@ -66,8 +92,11 @@ export function title({} = {}) {
 }
 
 export function description({
-  wordsPerSentenceAvg = 24,
-  wordsPerSentenceStd = 5,
+  wordsPerSentence = {
+    avg: 24,
+    std: 5,
+    min: 1,
+  },
 } = {}) {
   return function *(iterator) {
     let word;
@@ -79,7 +108,7 @@ export function description({
       word = _word;
       if (slen === 0) {
         word = capitalize(word);
-        slen = Math.max(1, gaussMS(wordsPerSentenceAvg, wordsPerSentenceStd));
+        slen = gaussMS(wordsPerSentence);
       }
       if (--slen === 0) {
         word += '.';
@@ -99,8 +128,23 @@ function capitalize(word) {
   return word[0].toUpperCase() + word.substring(1);
 }
 
-function gaussMS(mean, std) {
-  return Math.round(gaussRandom() * std + mean);
+// TODO: have a random variable expression
+function gaussMS(args) {
+  if (typeof args === 'number') {
+    return Math.round(avg);
+  }
+  let { avg, std, min, max } = args;
+  if (std === undefined) {
+    std = avg / 4;
+  }
+  let n = gaussRandom() * std + avg;
+  if (min !== undefined) {
+    n = Math.max(min, n);
+  }
+  if (max !== undefined) {
+    n = Math.min(max, n);
+  }
+  return Math.round(n);
 }
 
 function gaussRandom() {

package/src/data/markdown/index.js

@@ -0,0 +1,233 @@
+import { randomInt, imageUrl, shuffle } from '../utils.js';
+import * as lorem from '../lorem.js';
+
+// TODO: wild mode that generates edge cases
+
+export function markdown({ features, blocks = [8, 12] } = {}) {
+  // TODO: block features
+  return [
+    atxHeading({ features }),
+    paragraph({ features }),
+    fencedCodeBlock({ features }),
+    paragraph({ features }),
+    table({ features }),
+    image(),
+    paragraph({ features }),
+    hr(),
+    atxHeading({ features }),
+    paragraph({ features }),
+    list({ features }),
+    paragraph({ features }),
+  ].join('\n\n');
+}
+
+// leaf blocks //
+export function hr() {
+  // wild mode: while spaces at the beginning (< 4), in between, in the end
+  // wild mode: no line break for '*'
+  return '*-_'.charAt(randomInt(0, 2)).repeat(randomInt(3, 6));
+}
+
+export function atxHeading({ features, level = [1, 6], size = [1, 8], content }) {
+  const words = content || lorem.lorem({ size });
+  return `${'#'.repeat(randomInt(...level))} ${words}`;
+}
+
+export function setextHeading({ features, level = [1, 2], size = [1, 8], content }) {
+  const words = content || lorem.lorem({ size });
+  return `${words}\n${'=-'.charAt(randomInt(...level) - 1).repeat(3)}`;
+}
+
+export function linkReferenceDefinition({ label, destination, title }) {
+  return `[${label}]: ${destination}${title !== undefined ? ` ${title}` : ''}`;
+}
+
+export function indentedCodeBlock({ lang, content, size }) {
+  content = content || codeContent({ lang, size }); 
+  return indent(4, content);
+}
+
+export function fencedCodeBlock({ lang, content, size, fenceChar = '`' }) {
+  if (fenceChar === 'random') {
+    fenceChar = '`~'.charAt(randomInt(0, 1));
+  }
+  content = content || codeContent({ lang, size }); 
+  // TODO: escape fenceChar in content
+  return `${fenceChar.repeat(3)}${lang || ''}\n${content}\n${fenceChar.repeat(3)}`;
+}
+
+export function paragraph({ features, size = [20, 50] }) {
+  return lorem.lorem({ size, decorates: ['description', decorate({ features })] });
+}
+
+export function table({ features, columns = [2, 4], rows = [2, 8] }) {
+  columns = randomInt(...columns);
+  rows = randomInt(...rows);
+  const defs = [...multiply({ size: 1 }, columns - 1), { size: [3, 8] }];
+  const header = lorem.lorem({ size: columns, output: 'array' });
+  const delimiter = defs.map(() => '---');
+  const body = [ header, delimiter ];
+  for (let i = 0; i < rows - 1; i++) {
+    body.push(defs.map(({ size }) => lorem.lorem({ size })));
+  }
+  return body.map(tableRow).join('\n');
+}
+
+export function image({ url, imageSize = [400, 250], ...options } = {}) {
+  url = url || imageUrl(imageSize);
+  return `![${_content(options)}](${url})`;
+}
+
+// container blocks //
+export function blockquote({ features, size = [3, 5] }) {
+  // TODO
+  return _blockquote(lorem.lorem({ size }));
+}
+
+const LIST_ITEM_TYPES = ['ordered', 'bullet', 'task'];
+
+export function list({ features, type = 'random', count = [1, 8], size = [5, 15] }) {
+  count = typeof count === 'number' ? count : randomInt(...count);
+  const t = type === 'random' ? LIST_ITEM_TYPES[Math.floor(3 * Math.random())] : type;
+  const items = [];
+  while (count > 0) {
+    const c = randomInt(1, count);
+    let content = paragraph({ features, size });
+    if (c > 1) {
+      content += `\n${list({ features, type, count: c - 1, size })}`;
+    }
+    items.push(listItem(t, content));
+    count -= c;
+  }
+  return items.join('\n');
+}
+
+// inline //
+export function codeSpan(options) {
+  return `\`${_content(options)}\``;
+}
+
+export function emphasis({ level = [1, 3], options }) {
+  level = typeof level === 'number' ? level : randomInt(...level);
+  const str = '_*'.charAt(randomInt(0, 1)).repeat(level);
+  return `${str}${_content(options)}${str}`;
+}
+
+export function link({ url = 'https://miso.ai', ...options } = {}) {
+  return `[${_content(options)}](${url})`;
+}
+
+// TODO: ref link
+// TODO: autolink
+// TODO: hard line break
+
+const INLINE_FEATURES = {
+  'code-span': () => ['`', '`'],
+  'emphasis-1': () => multiply(_emphasisAdfix(1), 2),
+  'emphasis-2': () => multiply(_emphasisAdfix(2), 2),
+  'emphasis-3': () => multiply(_emphasisAdfix(3), 2),
+  'link': ({ url = 'https://miso.ai' } = {}) => [`[`, `](${url})`],
+};
+
+function _emphasisAdfix(level = [1, 3]) {
+  level = typeof level === 'number' ? level : randomInt(...level);
+  return '_*'.charAt(randomInt(0, 1)).repeat(level);
+}
+
+const INLINE_FEATURE_LIST = Object.keys(INLINE_FEATURES);
+const INLINE_FEATURE_SET = new Set(INLINE_FEATURE_LIST);
+
+// decorator //
+export function decorate({ features = INLINE_FEATURE_LIST, size = [1, 3], rest = [0, 8] } = {}) {
+  features = features.filter(f => INLINE_FEATURE_SET.has(f));
+
+  const unused = shuffle([...features]);
+  let unusedCursor = unused.length - 1;
+
+  const rollRest = () => typeof rest === 'number' ? rest : randomInt(...rest);
+  const rollFeatureSize = () => typeof size === 'number' ? size : randomInt(...size);
+  const rollFeatureType = () => unusedCursor >= 0 ? unused[unusedCursor--] : features[randomInt(0, features.length - 1)];
+
+  return function *(iterator) {
+    let count = rollRest();
+    let suffix;
+    let lastWord;
+    for (const word of iterator) {
+      if (lastWord) {
+        yield lastWord;
+      }
+      if (count === 0) {
+        if (suffix) {
+          lastWord = `${word}${suffix}`;
+          suffix = undefined;
+          count = rollRest();
+        } else {
+          const [prefix, s] = INLINE_FEATURES[rollFeatureType()]();
+          lastWord = `${prefix}${word}`;
+          suffix = s;
+          count = rollFeatureSize();
+        }
+      } else {
+        lastWord = word;
+        count--;
+      }
+    }
+    if (lastWord) {
+      yield suffix !== undefined ? `${lastWord}${suffix}` : lastWord;
+    }
+  };
+}
+
+// helper //
+function _content({ size = [1, 3], content } = {}) {
+  return content || lorem.lorem({ size });
+}
+
+function _blockquote(content) {
+  return content.split('\n').map(line => `> ${line}`).join('\n');
+}
+
+export function indent(size, content) {
+  return content.split('\n').map(line => ' '.repeat(size) + line).join('\n');
+}
+
+export function listItem(type, content) {
+  const [firstLine, restLines] = content.split('\n', 2);
+  const result = `${listItemPrefix(type)} ${firstLine}`;
+  const indentSize = type === 'ordered' ? 3 : 2;
+  return !restLines ? result : result + `\n${indent(indentSize, restLines)}`;
+}
+
+function listItemPrefix(type, checked = 'random') {
+  switch (type) {
+    case 'ordered':
+      return '1.';
+    case 'bullet':
+      return '-';
+    case 'task':
+      const mark = (checked === 'random' ? Math.random() < 0.5 : !!checked) ? 'x' : ' ';
+      return `- [${mark}]`;
+    default:
+      throw new Error(`unknown list item type: ${type}`);
+  }
+}
+
+function codeContent({ lang, size = [10, 30] }) {
+  // TODO
+  switch (lang) {
+    default:
+      return lorem.lorem({ output: 'multiline', size });
+  }
+}
+
+function tableRow(cells) {
+  return `| ${cells.join(' | ')} |`;
+}
+
+function multiply(obj, i) {
+  const arr = [];
+  for (let j = 0; j < i; j++) {
+    arr.push(typeof obj === 'function' ? obj() : obj);
+  }
+  return arr;
+}

package/src/data/products.js

@@ -1,5 +1,5 @@
 import * as u from './utils.js';
-import * as lorem from './lorem.js';
+import * as fields from './fields.js';
 
 export function *products({ rows, ...options } = {}) {
   for (let i = 0; i < rows; i++) {
@@ -9,43 +9,22 @@ export function *products({ rows, ...options } = {}) {
 
 function product({} = {}) {
   const id = u.id();
-  const prices = u.repeat(u.price, 1, 2);
+  const prices = u.repeat(fields.price, [1, 2]);
   prices.sort();
-  const seed = Math.floor(Math.random() * 1000);
 
   return {
     product_id: id,
-    authors: lorem.lorem({
-      min: 1,
-      max: 3,
-      fixedStarts: 0,
-      decorates: ['title'],
-      output: 'array',
-    }),
+    authors: fields.authors(),
     categories: [],
-    tags: lorem.lorem({
-      min: 1,
-      max: 4,
-      fixedStarts: 0,
-      output: 'array',
-    }),
-    title: lorem.lorem({
-      min: 2,
-      max: 6,
-      fixedStarts: 0,
-      decorates: ['title'],
-    }),
-    description: lorem.lorem({
-      min: 10,
-      max: 20,
-      decorates: ['description'],
-    }),
+    tags: fields.tags(),
+    title: fields.title(),
+    description: fields.description(),
     //html,
-    cover_image: `https://picsum.photos/seed/${seed}/300`,
+    cover_image: fields.image(),
     url: `/products/${id}`,
     sale_price: prices[0],
     original_price: prices[prices.length - 1],
-    rating: u.rating(),
-    availability: u.availability(),
+    rating: fields.rating(),
+    availability: fields.availability(),
   };
 }

package/src/data/utils.js

@@ -1,9 +1,10 @@
 export function randomInt(min, max) {
-  return max > min ? min + Math.floor(Math.random() * (max - min)) : min;
+  return max == null || (max <= min) ? min : (min + Math.floor(Math.random() * (max - min)));
 }
 
-export function repeat(fn, min = 1, max = 2) {
-  const n = randomInt(min, max);
+// TODO: pass in size
+export function repeat(fn, range) {
+  const n = randomInt(...range);
   const result = [];
   for (let i = 0; i < n; i++) {
     result.push(fn());
@@ -15,14 +16,16 @@ export function id() {
   return Math.random().toString(36).substring(2, 10);
 }
 
-export function availability() {
-  return Math.random() > 0.3 ? 'IN_STOCK' : 'OUT_OF_STOCK';
-}
-
-export function price() {
-  return Math.floor(Math.random() * 10000) / 100;
+export function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
 }
 
-export function rating() {
-  return Math.floor(Math.random() * 500) / 100 + 1;
+export function imageUrl(size) {
+  const seed = Math.floor(Math.random() * 1000);
+  const sizePath = Array.isArray(size) ? size.length > 1 ? `${size[0]}/${size[1]}` : `${size[0]}` : `${size}`;
+  return `https://picsum.photos/seed/${seed}/${sizePath}`;
 }

package/src/index.js

@@ -3,12 +3,13 @@ import Router from '@koa/router';
 import cors from '@koa/cors';
 import serveStatic from 'koa-static';
 import { koaBody } from 'koa-body';
-import api from './api/index.js';
+import _api from './api/index.js';
 import { exclusion } from './utils.js';
 
-export default function doggoganger({ port = 9901, serve = false } = {}) {
+export default function doggoganger({ port = 9901, serve = false, ...options } = {}) {
   const app = new Koa();
   const router = new Router();
+  const api = _api(options);
   
   router.use('/api', api.routes(), api.allowedMethods());